{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notes:\n",
    " * revised and tuned configuration, updated views\n",
    " * training on full dataset (including Y3, new light curves, fixes)\n",
    " * trained with updated star radius estimations, multiple duplicates removed\n",
    " * removed instar examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['/mnt/tess/astronet/checkpoints/revised_tuned_35_run_1/1/AstroCNNModel_revised_tuned_20220219_190314',\n",
       " '/mnt/tess/astronet/checkpoints/revised_tuned_35_run_1/2/AstroCNNModel_revised_tuned_20220219_191000',\n",
       " '/mnt/tess/astronet/checkpoints/revised_tuned_35_run_1/3/AstroCNNModel_revised_tuned_20220219_191635',\n",
       " '/mnt/tess/astronet/checkpoints/revised_tuned_35_run_1/4/AstroCNNModel_revised_tuned_20220219_192313',\n",
       " '/mnt/tess/astronet/checkpoints/revised_tuned_35_run_1/5/AstroCNNModel_revised_tuned_20220219_192947',\n",
       " '/mnt/tess/astronet/checkpoints/revised_tuned_35_run_1/6/AstroCNNModel_revised_tuned_20220219_193623',\n",
       " '/mnt/tess/astronet/checkpoints/revised_tuned_35_run_1/7/AstroCNNModel_revised_tuned_20220219_194256',\n",
       " '/mnt/tess/astronet/checkpoints/revised_tuned_35_run_1/8/AstroCNNModel_revised_tuned_20220219_194931',\n",
       " '/mnt/tess/astronet/checkpoints/revised_tuned_35_run_1/9/AstroCNNModel_revised_tuned_20220219_195605',\n",
       " '/mnt/tess/astronet/checkpoints/revised_tuned_35_run_1/10/AstroCNNModel_revised_tuned_20220219_200240']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "chkpt_root = '/mnt/tess/astronet/checkpoints/revised_tuned_35_run_1'\n",
    "data_files = '/mnt/tess/astronet/tfrecords-35-val/*'\n",
    "tces_file = '/mnt/tess/astronet/tces-v12-val.csv'\n",
    "\n",
    "nruns = 10\n",
    "\n",
    "def load_ensemble(chkpt_root, nruns):\n",
    "    checkpts = []\n",
    "    for i in range(nruns):\n",
    "        parent = os.path.join(chkpt_root, str(i + 1))\n",
    "        if not os.path.exists(parent):\n",
    "            break\n",
    "        all_dirs = os.listdir(parent)\n",
    "        if not all_dirs:\n",
    "            break\n",
    "        d, = all_dirs\n",
    "        checkpts.append(os.path.join(parent, d))\n",
    "    return checkpts\n",
    "\n",
    "paths = load_ensemble(chkpt_root, nruns)\n",
    "paths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running model 1\n",
      "2461 records\n",
      "Running model 2\n",
      "2461 records\n",
      "Running model 3\n",
      "2461 records\n",
      "Running model 4\n",
      "2461 records\n",
      "Running model 5\n",
      "2461 records\n",
      "Running model 7\n",
      "2461 records\n",
      "Running model 8\n",
      "2461 records\n",
      "Running model 9\n",
      "2461 records\n",
      "Running model 10\n",
      "2461 records\n"
     ]
    }
   ],
   "source": [
    "import getpass\n",
    "import os\n",
    "from astronet import predict\n",
    "import tensorflow as tf\n",
    "\n",
    "\n",
    "def run_predictions(path):\n",
    "    predict.FLAGS = predict.parser.parse_args([\n",
    "      '--model_dir', path,\n",
    "      '--data_files', data_files,\n",
    "      '--output_file', '',\n",
    "    ])\n",
    "\n",
    "    return predict.predict()\n",
    "\n",
    "\n",
    "paths = load_ensemble(chkpt_root, nruns)\n",
    "ensemble_preds = []\n",
    "config = None\n",
    "for i, path in enumerate(paths):\n",
    "    print(f'Running model {i + 1}')\n",
    "    preds, config = run_predictions(path)\n",
    "    ensemble_preds.append(preds.set_index('tic_id'))\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = ['disp_e', 'disp_n', 'disp_j', 'disp_s', 'disp_b']\n",
    "\n",
    "col_e = labels.index('disp_e')\n",
    "thresh = 0.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "agg_preds = {}\n",
    "\n",
    "for preds in ensemble_preds:\n",
    "    for tic_id in preds.index:\n",
    "        if tic_id not in agg_preds:\n",
    "            agg_preds[tic_id] = []\n",
    "\n",
    "        row = preds[preds.index == tic_id]\n",
    "        pred_v = row.values[0]\n",
    "        if len(row.values) > 1:\n",
    "            print(f'Warning: duplicate predictions for {tic_id}')\n",
    "        if pred_v[col_e] >= thresh:\n",
    "            agg_preds[tic_id].append('disp_e')\n",
    "        else:\n",
    "            masked_v = [v if i != col_e else 0 for i, v in enumerate(pred_v)]\n",
    "            agg_preds[tic_id].append(preds.columns[np.argmax(masked_v)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_preds = []\n",
    "for tic_id in list(agg_preds.keys()):\n",
    "    counts = {l: 0 for l in labels}\n",
    "    for e in agg_preds[tic_id]:\n",
    "        counts[e] += 1\n",
    "    maxcount = max(counts.values())\n",
    "    counts.update({\n",
    "        'tic_id': tic_id,\n",
    "        'maxcount': maxcount,\n",
    "    })\n",
    "    final_preds.append(counts)\n",
    "    \n",
    "final_preds = pd.DataFrame(final_preds).set_index('tic_id')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "tce_table = pd.read_csv(tces_file, header=0).set_index('tic_id')\n",
    "for l in labels:\n",
    "    tce_table[l] = tce_table[l[:-1] + l[-1].upper()]\n",
    "tce_labels = tce_table[labels]\n",
    "\n",
    "pl = final_preds.join(tce_labels, on='tic_id', how='left', lsuffix='_p')\n",
    "\n",
    "pl.head()\n",
    "pd.set_option('display.max_columns', None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recall: 0.9846153846153847\n",
      "Precision: 0.7052341597796143\n"
     ]
    }
   ],
   "source": [
    "ppos = (pl['disp_e_p'] > 0)\n",
    "pos = (pl['disp_e'] > 0)\n",
    "\n",
    "pneg = (pl['disp_e_p'] == 0)\n",
    "neg = (pl['disp_e'] == 0)\n",
    "\n",
    "print('Recall:', len(pl[ppos & pos]) / len(pl[pos]))\n",
    "print('Precision:', len(pl[ppos & pos]) / len(pl[ppos]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "104485403\n",
      "141753278\n",
      "158159741\n",
      "393324927\n"
     ]
    }
   ],
   "source": [
    "for i in pl[pos & pneg][[]].join(tce_table, on='tic_id', how='left').index:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "277414027\n",
      "356776209\n",
      "416282321\n",
      "43306175\n",
      "136651206\n",
      "277848886\n",
      "278555119\n",
      "357302392\n",
      "395164445\n",
      "417208086\n",
      "469465627\n",
      "252588526\n",
      "431338538\n",
      "116498176\n",
      "192591652\n",
      "312060273\n",
      "332870317\n",
      "381847922\n",
      "450006142\n",
      "94280922\n",
      "127846210\n",
      "261814771\n",
      "269291226\n",
      "391032362\n",
      "408945155\n",
      "428942240\n",
      "55244346\n",
      "648359612\n",
      "82242456\n",
      "56861756\n",
      "29477537\n",
      "30318046\n",
      "63840400\n",
      "101496204\n",
      "122577745\n",
      "238829802\n",
      "241855882\n",
      "281543210\n",
      "335588842\n",
      "410407161\n",
      "842068824\n",
      "91987762\n",
      "165373714\n",
      "154271808\n",
      "159636125\n",
      "219824182\n",
      "267821182\n",
      "275628557\n",
      "230197530\n",
      "284266496\n",
      "9037655\n",
      "207466671\n",
      "164528404\n",
      "118398402\n",
      "161030195\n",
      "201601338\n",
      "21601170\n",
      "22892207\n",
      "261205462\n",
      "267363765\n",
      "270312112\n",
      "270342707\n",
      "271999852\n",
      "276738707\n",
      "278632192\n",
      "281578420\n",
      "291374558\n",
      "293328926\n",
      "293527927\n",
      "30275847\n",
      "302968162\n",
      "309650507\n",
      "311103813\n",
      "317097409\n",
      "31868634\n",
      "319865847\n",
      "320356995\n",
      "326693475\n",
      "344128598\n",
      "352290769\n",
      "370227522\n",
      "370327024\n",
      "373919592\n",
      "379191982\n",
      "384341508\n",
      "384740598\n",
      "38570890\n",
      "38679633\n",
      "404851508\n",
      "404851552\n",
      "404851966\n",
      "404934011\n",
      "40602499\n",
      "406091286\n",
      "407615704\n",
      "410087746\n",
      "41256189\n",
      "419611478\n",
      "446698252\n",
      "55601400\n",
      "283330382\n",
      "14209654\n",
      "16740282\n",
      "185607431\n",
      "188258751\n",
      "199376584\n",
      "202685576\n"
     ]
    }
   ],
   "source": [
    "for i in pl[neg & ppos][[]].join(tce_table, on='tic_id', how='left').index:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>disp_e</th>\n",
       "      <th>disp_n</th>\n",
       "      <th>disp_j</th>\n",
       "      <th>disp_s</th>\n",
       "      <th>disp_b</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tic_id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [disp_e, disp_n, disp_j, disp_s, disp_b]\n",
       "Index: []"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def compare(ensemble_preds, filter):\n",
    "    result = ensemble_preds[0][filter]\n",
    "    for preds in ensemble_preds[1:]:\n",
    "        result = result.append(preds[filter])\n",
    "    return result\n",
    "\n",
    "compare(ensemble_preds, preds.index == 340066802)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>disp_e_p</th>\n",
       "      <th>disp_n_p</th>\n",
       "      <th>disp_j_p</th>\n",
       "      <th>disp_s_p</th>\n",
       "      <th>disp_b_p</th>\n",
       "      <th>maxcount</th>\n",
       "      <th>disp_e</th>\n",
       "      <th>disp_n</th>\n",
       "      <th>disp_j</th>\n",
       "      <th>disp_s</th>\n",
       "      <th>disp_b</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tic_id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [disp_e_p, disp_n_p, disp_j_p, disp_s_p, disp_b_p, maxcount, disp_e, disp_n, disp_j, disp_s, disp_b]\n",
       "Index: []"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pl[pl.index == 340066802]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### PR curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "tics = set(ensemble_preds[0].index.values)\n",
    "\n",
    "tic_index = {v: i for i, v in enumerate(tics)}\n",
    "\n",
    "pred_es = np.zeros([len(ensemble_preds), len(tic_index)])\n",
    "for i, preds in enumerate(ensemble_preds):\n",
    "    for row in preds.iterrows():\n",
    "        tic, pred_e = row[0], row[1][col_e]\n",
    "        pred_es[i][tic_index[tic]] = pred_e\n",
    "\n",
    "lbl_es = np.zeros([len(tic_index)], dtype=np.bool)\n",
    "for row in tce_labels.iterrows():\n",
    "    tic, lbl_e = row[0], row[1]['disp_e']\n",
    "    if tic in tic_index:\n",
    "        lbl_es[tic_index[tic]] = (lbl_e > 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_cond_pos = int(np.sum(lbl_es))\n",
    "\n",
    "def pr_at_th(th):\n",
    "    pred_pos = np.any(pred_es >= th, axis=0)\n",
    "    true_pos = pred_pos & lbl_es\n",
    "    num_pred_pos = int(np.sum(pred_pos))\n",
    "    num_true_pos = int(np.sum(true_pos))\n",
    "    if num_pred_pos == 0:\n",
    "        return 1.0, 0.0\n",
    "    return float(num_true_pos) / float(num_pred_pos), float(num_true_pos) / float(num_cond_pos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AUC: 0.9755040807982173, max R: 1.0, max P: 1.0\n",
      "100% recall at: 43%, threshold: 0.03349856948857999\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x740 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "ps, rs, ths = ([], [], [])\n",
    "th = np.max(pred_es)\n",
    "while th >= 0.0:\n",
    "    p, r = pr_at_th(th)\n",
    "    ps.append(p)\n",
    "    rs.append(r)\n",
    "    ths.append(th)\n",
    "    th -= 0.0005\n",
    "    \n",
    "from sklearn import metrics\n",
    "\n",
    "print(f'AUC: {metrics.auc(rs, ps)}, max R: {max(rs)}, max P: {max(ps)}')\n",
    "    \n",
    "i = len(rs) - 1\n",
    "while rs[i] == 1.0:\n",
    "    i -= 1\n",
    "i += 1\n",
    "print(f'100% recall at: {int(ps[i] * 100)}%, threshold: {ths[i]}')\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(6, 3.7), dpi=200)\n",
    "\n",
    "ax.spines['top'].set_color('#808080')\n",
    "ax.spines['right'].set_color('#808080')\n",
    "ax.spines['left'].set_color('#808080')\n",
    "ax.spines['bottom'].set_color('#808080')\n",
    "ax.tick_params(direction='in', color='#808080')\n",
    "\n",
    "plt.grid(color='#c0c0c0', linestyle='--', linewidth=0.5)\n",
    "\n",
    "plt.ylabel('Precision', fontweight='bold')\n",
    "plt.xlabel('Recall', fontweight='bold')\n",
    "\n",
    "plt.xlim((0.0, 1.0))\n",
    "plt.ylim((0.0, 1.0))\n",
    "\n",
    "_ = plt.plot(rs, ps)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
